{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "import numpy as np\n",
    "import random"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Maze():\n",
    "    def __init__(self, size, blocking_pos, goal):\n",
    "        \"\"\"\n",
    "\n",
    "        :param size: tuple (width, height)\n",
    "        :param blocking_pos: [(x,y), ...] positions of blocking mazes.\n",
    "                             Here, expect lower left corner as origin and start from 1\n",
    "        :param goal: (x,y) position of goal\n",
    "\n",
    "        Example:\n",
    "        size = (3,3)\n",
    "        blocking_pos = [(1,1)]\n",
    "        goal = (3,3)\n",
    "\n",
    "        Result Maze:\n",
    "        0 0 g\n",
    "        0 0 0\n",
    "        1 0 0\n",
    "        where 1 is blocking block and g is the goal\n",
    "        \"\"\"\n",
    "        self.width, self.height = size\n",
    "        self.blocking_pos = blocking_pos\n",
    "        self.goal = goal\n",
    "\n",
    "    def step(self, current_state, action):\n",
    "        \"\"\"\n",
    "        :param current_state: (x,y) current pos\n",
    "        :param action: action from ['up', 'down', 'right', 'left']\n",
    "        :return: reward, next_state\n",
    "        \"\"\"\n",
    "        x, y = current_state\n",
    "        dx, dy = 0, 0\n",
    "        if action == 'up':\n",
    "            dy = 1\n",
    "        elif action == 'down':\n",
    "            dy = -1\n",
    "        elif action == 'left':\n",
    "            dx = -1\n",
    "        elif action == 'right':\n",
    "            dx = 1\n",
    "        else:\n",
    "            raise ValueError(f'action {action} is undefined')\n",
    "\n",
    "        # make sure they are in bound\n",
    "        x_change = min(self.width, max(1, x+dx))\n",
    "        y_change = min(self.height, max(1, y+dy))\n",
    "\n",
    "        # make sure they are not blocked\n",
    "        if (x_change, y_change) in self.blocking_pos:\n",
    "            # rollback\n",
    "            x_change, y_change = x,y\n",
    "\n",
    "        # check goal\n",
    "        if (x_change, y_change) == self.goal:\n",
    "            reward = 1\n",
    "        else:\n",
    "            reward = 0\n",
    "\n",
    "        return reward, (x_change, y_change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "class DynaQ:\n",
    "    def __init__(self, alpha=0.1, gamma=0.95, eps=0.2, planning_n = 50):\n",
    "        self.alpha = alpha\n",
    "        self.gamma = gamma\n",
    "        self.eps = eps\n",
    "        self.planning_n = planning_n\n",
    "        self.action_space = ['up', 'down', 'right', 'left']\n",
    "        self.model = defaultdict(int)\n",
    "        self.Q = defaultdict(int)\n",
    "        # key in both Q and model: tuple((x,y),a)\n",
    "\n",
    "    def greedy(self, state):\n",
    "        Q_list = [self.Q[state,a] for a in self.action_space]\n",
    "        _max = max(Q_list)\n",
    "        if _max == 0:\n",
    "            # no actions has been learned\n",
    "            return np.random.choice(self.action_space)\n",
    "        else:\n",
    "            tie_actions = []\n",
    "            for i, q in enumerate(Q_list):\n",
    "                if  q == _max:\n",
    "                    tie_actions.append(self.action_space[i])\n",
    "            return np.random.choice(tie_actions)\n",
    "\n",
    "    def eps_greedy(self, state):\n",
    "        if np.random.random() > self.eps:\n",
    "            return self.greedy(state)\n",
    "        else:\n",
    "            # return a random action\n",
    "            return np.random.choice(self.action_space)\n",
    "\n",
    "    def update(self, state, action, next_state, reward):\n",
    "        greedy_action = self.greedy(next_state)\n",
    "        self.Q[state,action] += self.alpha*(reward + self.gamma*self.Q[next_state,greedy_action] - self.Q[state,action])\n",
    "\n",
    "    def model_update(self, state, action, next_state, reward):\n",
    "        self.model[state,action] = reward, next_state\n",
    "\n",
    "    def planning(self):\n",
    "        for _ in range(self.planning_n):\n",
    "            state, action = random.sample(self.model.keys(), 1)[0]\n",
    "            reward, next_state = self.model[state,action]\n",
    "            self.update(state, action, next_state, reward)\n",
    "    def reset(self):\n",
    "        self.Q = defaultdict(int)\n",
    "        self.model = defaultdict(int)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "# Most of the code here are copy paste from DynaQ\n",
    "# Not using inheritance on purpose (to make copy of the class easier)\n",
    "class DynaQPlus:\n",
    "    def __init__(self, alpha=0.1, gamma=0.95, eps=0.2, planning_n = 50, k = 0.001):\n",
    "        self.alpha = alpha\n",
    "        self.gamma = gamma\n",
    "        self.eps = eps\n",
    "        self.planning_n = planning_n\n",
    "        self.action_space = ['up', 'down', 'right', 'left']\n",
    "        self.model = defaultdict(int)\n",
    "        self.Q = defaultdict(int)\n",
    "        self.k = k\n",
    "        # key in both Q and model: tuple((x,y),a)\n",
    "        self.tao_dict = defaultdict(int)\n",
    "\n",
    "    def greedy(self, state):\n",
    "        Q_list = [self.Q[state,a] for a in self.action_space]\n",
    "        _max = max(Q_list)\n",
    "        if _max == 0:\n",
    "            # no actions has been learned\n",
    "            return np.random.choice(self.action_space)\n",
    "        else:\n",
    "            tie_actions = []\n",
    "            for i, q in enumerate(Q_list):\n",
    "                if  q == _max:\n",
    "                    tie_actions.append(self.action_space[i])\n",
    "            return np.random.choice(tie_actions)\n",
    "\n",
    "    def eps_greedy(self, state):\n",
    "        if np.random.random() > self.eps:\n",
    "            action = self.greedy(state)\n",
    "        else:\n",
    "            # return a random action\n",
    "            action = np.random.choice(self.action_space)\n",
    "        for k in self.tao_dict.keys():\n",
    "            if k != (state, action):\n",
    "                self.tao_dict[k] += 1\n",
    "        self.tao_dict[state,action] = 0\n",
    "        return action\n",
    "\n",
    "    def update(self, state, action, next_state, reward):\n",
    "        greedy_action = self.greedy(next_state)\n",
    "        self.Q[state,action] += self.alpha*(reward + self.gamma*self.Q[next_state,greedy_action] - self.Q[state,action])\n",
    "\n",
    "    def model_update(self, state, action, next_state, reward):\n",
    "        self.model[state,action] = reward, next_state\n",
    "        \n",
    "    # ------difference of dynaQ+ is here------\n",
    "    def bonus(self, state, action):\n",
    "        return self.k*np.sqrt(self.tao_dict[state,action])\n",
    "    def planning(self):\n",
    "        for _ in range(self.planning_n):\n",
    "            state, action = random.sample(self.model.keys(), 1)[0]\n",
    "            reward, next_state = self.model[state,action]\n",
    "            bonus = self.bonus(state,action)\n",
    "            self.update(state, action, next_state, reward+bonus)\n",
    "            \n",
    "            \n",
    "    # ------difference of dynaQ+ is here------\n",
    "            \n",
    "    def reset(self):\n",
    "        self.Q = defaultdict(int)\n",
    "        self.model = defaultdict(int)\n",
    "        self.tao_dict = defaultdict(int)\n",
    "        "
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "class DynaQPlusExperiment:\n",
    "    def __init__(self, alpha=0.1, gamma=0.95, eps=0.2, planning_n = 50, k = 0.001):\n",
    "        self.alpha = alpha\n",
    "        self.gamma = gamma\n",
    "        self.eps = eps\n",
    "        self.planning_n = planning_n\n",
    "        self.action_space = ['up', 'down', 'right', 'left']\n",
    "        self.model = defaultdict(int)\n",
    "        self.Q = defaultdict(int)\n",
    "        self.k = k\n",
    "        # key in both Q and model: tuple((x,y),a)\n",
    "        self.tao_dict = defaultdict(int)\n",
    "\n",
    "    def greedy(self, state):\n",
    "        Q_list = [self.Q[state,a] + self.bonus(state,a) for a in self.action_space]\n",
    "        _max = max(Q_list)\n",
    "        if _max == 0:\n",
    "            # no actions has been learned\n",
    "            return np.random.choice(self.action_space)\n",
    "        else:\n",
    "            tie_actions = []\n",
    "            for i, q in enumerate(Q_list):\n",
    "                if  q == _max:\n",
    "                    tie_actions.append(self.action_space[i])\n",
    "            return np.random.choice(tie_actions)\n",
    "\n",
    "    def eps_greedy(self, state):\n",
    "        if np.random.random() > self.eps:\n",
    "            action = self.greedy(state)\n",
    "        else:\n",
    "            # return a random action\n",
    "            action = np.random.choice(self.action_space)\n",
    "        for k in self.tao_dict.keys():\n",
    "            if k != (state, action):\n",
    "                self.tao_dict[k] += 1\n",
    "        self.tao_dict[state,action] = 0\n",
    "        return action\n",
    "\n",
    "    def update(self, state, action, next_state, reward):\n",
    "        greedy_action = self.greedy(next_state)\n",
    "        self.Q[state,action] += self.alpha*(reward + self.gamma*self.Q[next_state,greedy_action] - self.Q[state,action])\n",
    "\n",
    "    def model_update(self, state, action, next_state, reward):\n",
    "        self.model[state,action] = reward, next_state\n",
    "\n",
    "    # ------difference of dynaQ+ is here------\n",
    "    def bonus(self, state, action):\n",
    "        return self.k*np.sqrt(self.tao_dict[state,action])\n",
    "    def planning(self):\n",
    "        for _ in range(self.planning_n):\n",
    "            state, action = random.sample(self.model.keys(), 1)[0]\n",
    "            reward, next_state = self.model[state,action]\n",
    "            self.update(state, action, next_state, reward)\n",
    "\n",
    "\n",
    "    # ------difference of dynaQ+ is here------\n",
    "\n",
    "    def reset(self):\n",
    "        self.Q = defaultdict(int)\n",
    "        self.model = defaultdict(int)\n",
    "        self.tao_dict = defaultdict(int)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "def game(agent):\n",
    "    EXPERIMENT = 5\n",
    "    HIST = []\n",
    "    # set env the one in Figure 8.2 of the book\n",
    "    env = Maze(size = (9,6), blocking_pos=[(3,3), (3,4), (3,5), (6,2), (8,4), (8,5), (8,6)], goal = (9,6))\n",
    "    EPISODE = 150\n",
    "    for experiment in range(EXPERIMENT):\n",
    "        agent.reset()\n",
    "        print(f'expeirment {experiment}')\n",
    "        hist = []\n",
    "        for episode in range(EPISODE):\n",
    "            if episode == 50:\n",
    "                # adding block\n",
    "                env.blocking_pos.append((3,6))\n",
    "                env.blocking_pos.append((3,2))\n",
    "                env.blocking_pos.append((8,4))\n",
    "                env.blocking_pos.append((8,5))\n",
    "            if episode == 100:\n",
    "                # removing another block\n",
    "                env.blocking_pos = []\n",
    "            state = (1,4)\n",
    "            for step in range(100000):\n",
    "                action = agent.eps_greedy(state)\n",
    "                reward, next_state = env.step(state,action)\n",
    "                # direct learn\n",
    "                agent.update(state, action, next_state, reward)\n",
    "                agent.model_update(state, action, next_state, reward)\n",
    "                if (step+1) % 1000 == 0:\n",
    "                    print(step)\n",
    "                if episode >= 1:\n",
    "                    agent.planning()\n",
    "                state = next_state\n",
    "                if reward == 1:\n",
    "                    hist.append(step)\n",
    "                    break\n",
    "            # start test\n",
    "        HIST.append(hist)\n",
    "    HIST = np.mean(HIST, axis = 0)\n",
    "    return HIST"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expeirment 0\n",
      "expeirment 1\n",
      "expeirment 2\n",
      "expeirment 3\n",
      "expeirment 4\n",
      "expeirment 0\n",
      "999\n",
      "expeirment 1\n",
      "999\n",
      "expeirment 2\n",
      "expeirment 3\n",
      "expeirment 4\n"
     ]
    }
   ],
   "source": [
    "# outer loop part\n",
    "HIST_DynaQ_5 = game(DynaQ(planning_n = 5))\n",
    "HIST_DynaQ_50 = game(DynaQ(planning_n = 50))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expeirment 0\n",
      "expeirment 1\n",
      "expeirment 2\n",
      "expeirment 3\n",
      "expeirment 4\n",
      "expeirment 0\n",
      "999\n",
      "expeirment 1\n",
      "expeirment 2\n",
      "expeirment 3\n",
      "expeirment 4\n"
     ]
    }
   ],
   "source": [
    "HIST_DynaQPlus_5 = game(DynaQPlus(planning_n = 5))\n",
    "HIST_DynaQPlus_50 = game(DynaQPlus(planning_n = 50))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expeirment 0\n",
      "expeirment 1\n",
      "expeirment 2\n",
      "expeirment 3\n",
      "expeirment 4\n",
      "expeirment 0\n",
      "expeirment 1\n",
      "expeirment 2\n",
      "expeirment 3\n",
      "expeirment 4\n"
     ]
    }
   ],
   "source": [
    "HIST_DynaQPlus_5_EXP = game(DynaQPlusExperiment(planning_n = 5))\n",
    "HIST_DynaQPlus_50_EXP = game(DynaQPlusExperiment(planning_n = 50))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 720x720 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw part\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('dark_background')\n",
    "plt.figure(figsize=(10, 10))\n",
    "plt.ylim(top=350)\n",
    "plt.title('dynaQ and dynaQ+ in blocking maze (overview)', fontsize = 'xx-large')\n",
    "plt.xlabel('Episodes (averaged over 5 experiments)', fontsize = 'xx-large')\n",
    "plt.ylabel('Steps',fontsize = 'xx-large')\n",
    "plt.plot(HIST_DynaQ_5, '-', c = 'green', label = 'dynaQ 5 steps')\n",
    "plt.plot(HIST_DynaQ_50, '-', c = 'blue', label = 'dynaQ 50 steps')\n",
    "\n",
    "plt.plot(HIST_DynaQPlus_5, '-', c = 'purple', label = 'dynaQPlus 5 steps')\n",
    "plt.plot(HIST_DynaQPlus_50, '-', c = 'red', label = 'dynaQPlus 50 steps')\n",
    "\n",
    "plt.plot(HIST_DynaQPlus_5_EXP, '-', c = 'orange', label = 'dynaQPlus Experiment method 5 steps')\n",
    "plt.plot(HIST_DynaQPlus_50_EXP, '-', c = 'yellow', label = 'dynaQPlus Experiment method 50 steps')\n",
    "plt.legend(loc = 'best', prop = {'size':12})\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 720x720 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('dark_background')\n",
    "plt.figure(figsize=(10, 10))\n",
    "plt.ylim(top=50)\n",
    "plt.title('dynaQ and dynaQ+ in blocking maze (smaller range)', fontsize = 'xx-large')\n",
    "plt.xlabel('Episodes (averaged over 5 experiments)', fontsize = 'xx-large')\n",
    "plt.ylabel('Steps',fontsize = 'xx-large')\n",
    "plt.plot(HIST_DynaQ_5, '-', c = 'blue', label = 'dynaQ 5 steps')\n",
    "\n",
    "plt.plot(HIST_DynaQPlus_5, '-', c = 'red', label = 'dynaQPlus 5 steps')\n",
    "plt.legend(loc = 'best', prop = {'size':12})\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 720x720 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('dark_background')\n",
    "plt.figure(figsize=(10, 10))\n",
    "plt.ylim(top=50)\n",
    "plt.title('dynaQ+ and dynaQ+ new method in blocking maze', fontsize = 'xx-large')\n",
    "plt.xlabel('Episodes (averaged over 5 experiments)', fontsize = 'xx-large')\n",
    "plt.ylabel('Steps',fontsize = 'xx-large')\n",
    "plt.plot(HIST_DynaQPlus_50, '-', c = 'blue', label = 'dynaQPlus 50 steps')\n",
    "plt.plot(HIST_DynaQPlus_50_EXP, '-', c = 'red', label = 'dynaQPlus experiment 50 steps')\n",
    "plt.legend(loc = 'best', prop = {'size':12})\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this experiment, I rebuild the example in figure 8.2. Then I\n",
    "change block to increase the difficulty at episode 50 and eliminate all blocks\n",
    "from map at episode 100.\n",
    "\n",
    "Result: DynaQ+ with experiment method will have lower variance after convergence but\n",
    "it takes much longer time to re-converge when environment get worse. I think it is due to picking\n",
    " action instead of rewriting q values will make spread of value change slower, but also make the meaningless\n",
    " exploration fewer.\n",
    "\n",
    "All methods show insensitive with the better condition. I think it is because they are not THAT better.\n",
    "Put into another experiment where optimal route is much shorter would be better.\n",
    "\n",
    "Readers are welcomed to do their own experiment.\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}